package com.solr.web.utils;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

public class pinyin4jUtils {   
	  
    /** 
     * 汉字转换位汉语拼音首字母，英文字符不变，特殊字符丢失 支持多音字，生成方式如（长沙市长:cssc,zssz,zssc,cssz） 
     *  
     * 这个方法不太符合我创建索引的要求---我要的是数组--自己重建一个 
     * @param chines 
     *            汉字 
     * @return 拼音 字符串 
     */   
    public static String converterToFirstSpell(String chines) {   
        return parseTheChineseByObject(discountTheChinese(MinMethod(chines).toString()));   
    }   
  
    /** 
     *  
     * @描述：返回类型调整为数组 
     * @param chines 
     * @return 
     * @return String[] 
     * @exception 
     * @createTime：2016年3月22日 
     * @author: songqinghu 
     */  
    public static Set<String> converterToFirstSpellToSet(String chines){  
        return parseTheChineseByObjectToSet(discountTheChinese(MinMethod(chines).toString()));   
    }  
  
  
    /** 
     *  
     * @描述：获取首字母方法抽取 
     * @param chines 
     * @return 
     * @return StringBuffer 
     * @exception 
     * @createTime：2016年3月22日 
     * @author: songqinghu 
     */  
    public static StringBuffer MinMethod(String chines){  
        StringBuffer pinyinName = new StringBuffer();   
        char[] nameChar = chines.toCharArray();   
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();   
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);   
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);   
        for (int i = 0; i < nameChar.length; i++) {   
            if (nameChar[i] > 128) { //char中1-127对应特殊字符和数字,字母  
                try {   
                    // 取得当前汉字的所有全拼   
                    String[] strs = PinyinHelper.toHanyuPinyinStringArray(   
                            nameChar[i], defaultFormat);   
                    if (strs != null) {   
                        for (int j = 0; j < strs.length; j++) {   
                            // 取首字母   
                            pinyinName.append(strs[j].charAt(0));   
                            if (j != strs.length - 1) {   
                                pinyinName.append(",");   
                            }   
                        }   
                    }   
                    // else {   
                    // pinyinName.append(nameChar[i]);   
                    // }   
                } catch (BadHanyuPinyinOutputFormatCombination e) {   
                    e.printStackTrace();   
                }   
            } else {   
                pinyinName.append(nameChar[i]);   
            }   
            pinyinName.append(" ");   
        }   
        return pinyinName;  
    }  
  
    /** 
     * 汉字转换位汉语全拼，英文字符不变，特殊字符丢失 
     * 支持多音字，生成方式如（重当参:zhongdangcen,zhongdangcan,chongdangcen 
     * ,chongdangshen,zhongdangshen,chongdangcan） 
     *  不符合 我的要求---重新写一个返回值为Set<String>类型 
     * @param chines 
     *            汉字 
     * @return 拼音 
     */   
    public static String converterToSpell(String chines) {   
        // return pinyinName.toString();   
        return parseTheChineseByObject(discountTheChinese(midConoverterToSpell(chines).toString()));   
    }   
    /** 
     *  
     * @描述：返回值为set 
     * @param chines 
     * @return 
     * @return Set<String> 
     * @exception 
     * @createTime：2016年3月22日 
     * @author: songqinghu 
     */  
    public static Set<String> converterToSpellToSet(String chines){  
        return parseTheChineseByObjectToSet(discountTheChinese(midConoverterToSpell(chines).toString()));   
    }  
  
  
    /** 
     * @描述：方法抽取 
     * @param chines 
     * @return 
     * @return StringBuffer 
     * @exception 
     * @createTime：2016年3月22日 
     * @author: songqinghu 
     */  
    private  static StringBuffer midConoverterToSpell(String chines){  
        StringBuffer pinyinName = new StringBuffer();   
        char[] nameChar = chines.toCharArray();   
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();   
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);   
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);   
        for (int i = 0; i < nameChar.length; i++) {   
            if (nameChar[i] > 128) {   
                try {   
                    // 取得当前汉字的所有全拼   
                    String[] strs = PinyinHelper.toHanyuPinyinStringArray(   
                            nameChar[i], defaultFormat);   
                    if (strs != null) {   
                        for (int j = 0; j < strs.length; j++) {   
                            pinyinName.append(strs[j]);   
                            if (j != strs.length - 1) {   
                                pinyinName.append(",");   
                            }   
                        }   
                    }   
                } catch (BadHanyuPinyinOutputFormatCombination e) {   
                    e.printStackTrace();   
                }   
            } else {   
                pinyinName.append(nameChar[i]);   
            }   
            pinyinName.append(" ");   
        }   
  
        return pinyinName;  
    }  
  
  
    /** 
     * 去除多音字重复数据 
     *  
     * @param theStr 
     * @return 
     */   
    private static List<Map<String, Integer>> discountTheChinese(String theStr) {   
        // 去除重复拼音后的拼音列表   
        List<Map<String, Integer>> mapList = new ArrayList<Map<String, Integer>>();   
        // 用于处理每个字的多音字，去掉重复   
        Map<String, Integer> onlyOne = null;   
        String[] firsts = theStr.split(" ");   
        // 读出每个汉字的拼音   
        for (String str : firsts) {   
            onlyOne = new Hashtable<String, Integer>();   
            String[] china = str.split(",");   
            // 多音字处理   
            for (String s : china) {   
                Integer count = onlyOne.get(s);   
                if (count == null) {   
                    onlyOne.put(s, new Integer(1));   
                } else {   
                    onlyOne.remove(s);   
                    count++;   
                    onlyOne.put(s, count);   
                }   
            }   
            mapList.add(onlyOne);   
        }   
        return mapList;   
    }   
  
    /** 
     * 解析并组合拼音，对象合并方案(推荐使用) 
     *  
     * @return 
     */   
    private static String parseTheChineseByObject(   
            List<Map<String, Integer>> list) {   
        Map<String, Integer> first = MinparseTheChineseByObject(list);  
        String returnStr = "";   
        if (first != null) {   
            // 遍历取出组合字符串   
            for (String str : first.keySet()) {   
                returnStr += (str + ",");   
            }   
        }   
        if (returnStr.length() > 0) {   
            returnStr = returnStr.substring(0, returnStr.length() - 1);   
        }   
        return returnStr;   
    }   
    /** 
     * 解析并组合拼音，对象合并方案(推荐使用)---返回set<String> 
     *  
     * @return 
     */   
    private static  Set<String> parseTheChineseByObjectToSet(   
            List<Map<String, Integer>> list) {   
        Map<String, Integer> first = MinparseTheChineseByObject(list);  
        Set<String> result = null;   
        if (first != null && first.keySet().size()>0) {   
            // 遍历取出组合字符串   
            result = first.keySet();  
        }   
        return result;   
    }   
   /** 
    *  
    * @描述：方法抽取 
    * @param list 
    * @return 
    * @return Map<String,Integer> 
    * @exception 
    * @createTime：2016年3月22日 
    * @author: songqinghu 
    */  
    private static Map<String,Integer> MinparseTheChineseByObject(  
            List<Map<String, Integer>> list){  
        Map<String, Integer> first = null; // 用于统计每一次,集合组合数据   
        // 遍历每一组集合   
        for (int i = 0; i < list.size(); i++) {   
            // 每一组集合与上一次组合的Map   
            Map<String, Integer> temp = new Hashtable<String, Integer>();   
            // 第一次循环，first为空   
            if (first != null) {   
                // 取出上次组合与此次集合的字符，并保存   
                for (String s : first.keySet()) {   
                    for (String s1 : list.get(i).keySet()) {   
                        String str = s + s1;   
                        temp.put(str, 1);   
                    }   
                }   
                // 清理上一次组合数据   
                if (temp != null && temp.size() > 0) {   
                    first.clear();   
                }   
            } else {   
                for (String s : list.get(i).keySet()) {   
                    String str = s;   
                    temp.put(str, 1);   
                }   
            }   
            // 保存组合数据以便下次循环使用   
            if (temp != null && temp.size() > 0) {   
                first = temp;   
            }   
        }   
        return first;  
    }  
  
  
}
